#include "std_contitiaon_variable.h"

/**
 *! @brief std::unique_lock 和 std::lock_guard 是 C++ 标准库中的两种锁管理工具，它们都用于自动管理互斥锁的加锁和解锁过程，
 *!        但它们之间有一些关键区别：
 * 
 *!  std::unique_lock
 *        1). 更灵活：std::unique_lock 提供比 std::lock_guard 更多的功能。它允许你延迟锁定、提前解锁、重新锁定和移动锁。
 *        2). 占用更多资源：由于提供了更多功能，std::unique_lock 通常比 std::lock_guard 占用更多的资源（如内存）。
 *        3). 用于复杂场景：在需要锁的更灵活管理时（如条件变量、延迟锁定等场景）使用。
 * 
 *  Example:  
 *       std::mutex mtx;
 *       int shared_data = 0;
 *       void do_something() {
 *             std::unique_lock<std::mutex> lck(mtx);
 *             shared_data++;
 *             lck.unlock();                            // TODO: 提前解锁
 *
 *             // 执行不需要锁保护的操作
 *
 *             lck.lock();                              // TODO: 重新加锁
 *             shared_data++;
 *             // lck 在离开作用域时自动解锁               // TODO: 出作用域自动释放
 *       }
 * 
 * 
 *!  std::lock_guard
 *        1). 更简单、轻量：std::lock_guard 是一个简单的互斥锁管理工具，它在构造时加锁，在析构时解锁，没有额外的功能。
 *        2). 用于简单场景：当你只需要确保互斥锁在某个作用域内被持有时，使用 std::lock_guard 即可。
 * 
 * 
 * @return int 
 */


/**
 *! @brief  std::condition_variable 和 std::condition_variable_any 都是 C++ 中用于线程同步的条件变量，但它们在与互斥锁的兼容性方面有所不同。
 * 
 * 
 *!  std::condition_variable
 *      1). 互斥锁兼容性：std::condition_variable 只能与 std::unique_lock<std::mutex> 一起使用。这意味着它只能与标准的互斥锁（std::mutex）配合工作。
 *      2). 性能：通常来说，std::condition_variable 会比 std::condition_variable_any 有更好的性能，因为它专门针对标准互斥锁进行了优化。
 * 
 *      std::unique_lock<std::mutex> locker(m_mutex);
 *!		m_notEmpty.wait(locker, [this]{ return !m_queue.empty(); });      // condition_variable只能使用unuque_lock，其针对性的做了优化
 * 
 * 
 *!  std::condition_variable_any
 *      1). 互斥锁兼容性：std::condition_variable_any 能够与任何满足基本锁定和解锁操作的互斥锁一起使用，包括 std::unique_lock 和其他类型的锁（如 
 *          std::shared_lock 或自定义锁）。
 *      2). 灵活性：这提供了更多的灵活性，但可能会以牺牲一定的性能为代价。
 * 
 *!  两者的头文件都是:   #include <condition_variable>
 * 
 * @return int 
 */


/**
 *! @brief std::shared_lock  std::shared_lock 是 C++17 引入的一个类，它实现了共享所有权的互斥锁管理。这意味着多个 std::shared_lock 
 *!        实例可以同时拥有对同一个互斥量的共享访问权。std::shared_lock 通常与共享互斥量（如 std::shared_mutex 或 std::shared_timed_mutex）
 *!        一起使用，允许多个读取者线程同时访问某个资源，同时仍然提供排他写入访问。
 * 
 * 
 *       1). 共享锁定：多个 std::shared_lock 实例可以同时锁定同一个互斥量，允许多个线程共享读取访问。
 *       2). 与 std::shared_mutex 配合使用：std::shared_lock 通常与 std::shared_mutex 结合使用，后者支持共享和排他锁定。
 *       3). 自动管理锁的生命周期：std::shared_lock 在构造时获取锁，在析构时释放锁，类似于 std::unique_lock 和 std::lock_guard。
 * 
 *! shared_lock + shared_mutex 通常用于共享读取 
 * 
 * 
 */

SyncQueue<int> syncQueue(5);

void PutDatas() {
	for (int i = 0; i < 20; ++i) {
		syncQueue.put(888);
	}
}

void TakeDatas() {
	int x = 0;

	for (int i = 0; i < 20; ++i) {
		syncQueue.pop(x);
		std::cout << x << std::endl;
	}
}


int std_condition_variable () {
    std::thread t1(PutDatas);
	std::thread t2(TakeDatas);

	t1.join();
	t2.join();


    return 0;
}